home *** CD-ROM | disk | FTP | other *** search
/ Champak 52 / Volume 52 - JOGO DISK .iso / Games / scoobysnackmachine.swf / scripts / __Packages / Levels / LevelData_29.as < prev    next >
Text File  |  2007-10-01  |  78KB  |  1,639 lines

  1. var ┬º\x01┬º = 188;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 188)
  6.    {
  7.       set("\x01",eval("\x01") + 52);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 704)
  12.    {
  13.       set("\x01",eval("\x01") - 158);
  14.       ┬º┬ºpush(true);
  15.       continue;
  16.    }
  17.    if(eval("\x01") == 541)
  18.    {
  19.       set("\x01",eval("\x01") + 163);
  20.       continue;
  21.    }
  22.    if(eval("\x01") == 383)
  23.    {
  24.       set("\x01",eval("\x01") + 193);
  25.       if(┬º┬ºpop())
  26.       {
  27.          set("\x01",eval("\x01") - 126);
  28.       }
  29.       continue;
  30.    }
  31.    if(eval("\x01") == 463)
  32.    {
  33.       set("\x01",eval("\x01") - 147);
  34.       if(┬º┬ºpop())
  35.       {
  36.          set("\x01",eval("\x01") + 138);
  37.       }
  38.       continue;
  39.    }
  40.    if(eval("\x01") == 827)
  41.    {
  42.       set("\x01",eval("\x01") - 123);
  43.       continue;
  44.    }
  45.    if(eval("\x01") == 647)
  46.    {
  47.       set("\x01",eval("\x01") + 9);
  48.       continue;
  49.    }
  50.    if(eval("\x01") == 712)
  51.    {
  52.       set("\x01",eval("\x01") - 358);
  53.       break;
  54.    }
  55.    if(eval("\x01") == 862)
  56.    {
  57.       set("\x01",eval("\x01") - 399);
  58.       ┬º┬ºpush(true);
  59.       continue;
  60.    }
  61.    if(eval("\x01") == 325)
  62.    {
  63.       set("\x01",eval("\x01") + 58);
  64.       ┬º┬ºpush(true);
  65.       continue;
  66.    }
  67.    if(eval("\x01") == 546)
  68.    {
  69.       set("\x01",eval("\x01") - 171);
  70.       if(┬º┬ºpop())
  71.       {
  72.          set("\x01",eval("\x01") + 1);
  73.       }
  74.       continue;
  75.    }
  76.    if(eval("\x01") == 376)
  77.    {
  78.       set("\x01",eval("\x01") + 280);
  79.       continue;
  80.    }
  81.    if(eval("\x01") == 557)
  82.    {
  83.       set("\x01",eval("\x01") - 217);
  84.       ┬º┬ºpush(┬º┬ºpop()[┬º┬ºpop()]);
  85.       break;
  86.    }
  87.    if(eval("\x01") == 240)
  88.    {
  89.       set("\x01",eval("\x01") + 317);
  90.       if(┬º┬ºpop())
  91.       {
  92.          set("\x01",eval("\x01") - 217);
  93.       }
  94.       continue;
  95.    }
  96.    if(eval("\x01") == 950)
  97.    {
  98.       set("\x01",eval("\x01") - 93);
  99.       continue;
  100.    }
  101.    if(eval("\x01") == 450)
  102.    {
  103.       set("\x01",eval("\x01") + 114);
  104.       continue;
  105.    }
  106.    if(eval("\x01") == 935)
  107.    {
  108.       set("\x01",eval("\x01") - 78);
  109.       continue;
  110.    }
  111.    if(eval("\x01") == 340)
  112.    {
  113.       set("\x01",eval("\x01") + 522);
  114.       continue;
  115.    }
  116.    if(eval("\x01") == 576)
  117.    {
  118.       set("\x01",eval("\x01") - 126);
  119.       break;
  120.    }
  121.    if(eval("\x01") == 354)
  122.    {
  123.       set("\x01",eval("\x01") + 147);
  124.       continue;
  125.    }
  126.    if(eval("\x01") == 590)
  127.    {
  128.       set("\x01",eval("\x01") - 26);
  129.       continue;
  130.    }
  131.    if(eval("\x01") == 989)
  132.    {
  133.       set("\x01",eval("\x01") - 127);
  134.       continue;
  135.    }
  136.    if(eval("\x01") == 356)
  137.    {
  138.       set("\x01",eval("\x01") + 145);
  139.       continue;
  140.    }
  141.    if(eval("\x01") == 962)
  142.    {
  143.       set("\x01",eval("\x01") - 365);
  144.       if(┬º┬ºpop())
  145.       {
  146.          set("\x01",eval("\x01") + 230);
  147.       }
  148.       continue;
  149.    }
  150.    if(eval("\x01") == 316)
  151.    {
  152.       set("\x01",eval("\x01") + 138);
  153.       loop1:
  154.       while(true)
  155.       {
  156.          if(┬º┬ºpop() == ┬º┬ºpop())
  157.          {
  158.             set("\x01",eval("\x01") - 199);
  159.          }
  160.          else if(eval("\x01") == 824)
  161.          {
  162.             set("\x01",eval("\x01") - 6);
  163.             ┬º┬ºpush(true);
  164.          }
  165.          else if(eval("\x01") == 779)
  166.          {
  167.             set("\x01",eval("\x01") + 55);
  168.             ┬º┬ºpush(true);
  169.          }
  170.          else if(eval("\x01") == 808)
  171.          {
  172.             set("\x01",eval("\x01") - 733);
  173.          }
  174.          else if(eval("\x01") == 834)
  175.          {
  176.             set("\x01",eval("\x01") - 371);
  177.             if(┬º┬ºpop())
  178.             {
  179.                set("\x01",eval("\x01") + 453);
  180.             }
  181.          }
  182.          else
  183.          {
  184.             if(eval("\x01") == 964)
  185.             {
  186.                set("\x01",eval("\x01") - 934);
  187.                break loop0;
  188.             }
  189.             if(eval("\x01") == 604)
  190.             {
  191.                set("\x01",eval("\x01") + 175);
  192.             }
  193.             else if(eval("\x01") == 818)
  194.             {
  195.                set("\x01",eval("\x01") + 146);
  196.                if(┬º┬ºpop())
  197.                {
  198.                   set("\x01",eval("\x01") - 934);
  199.                }
  200.             }
  201.             else if(eval("\x01") == 166)
  202.             {
  203.                set("\x01",eval("\x01") + 579);
  204.             }
  205.             else if(eval("\x01") == 924)
  206.             {
  207.                set("\x01",eval("\x01") - 258);
  208.             }
  209.             else if(eval("\x01") == 666)
  210.             {
  211.                set("\x01",eval("\x01") - 174);
  212.                ┬º┬ºpush(true);
  213.             }
  214.             else if(eval("\x01") == 286)
  215.             {
  216.                set("\x01",eval("\x01") + 380);
  217.             }
  218.             else if(eval("\x01") == 937)
  219.             {
  220.                set("\x01",eval("\x01") - 192);
  221.             }
  222.             else if(eval("\x01") == 229)
  223.             {
  224.                set("\x01",eval("\x01") - 20);
  225.                ┬º┬ºpush(true);
  226.             }
  227.             else
  228.             {
  229.                if(eval("\x01") == 978)
  230.                {
  231.                   set("\x01",eval("\x01") - 170);
  232.                   break loop0;
  233.                }
  234.                if(eval("\x01") == 75)
  235.                {
  236.                   set("\x01",eval("\x01") + 45);
  237.                   ┬º┬ºpush(true);
  238.                }
  239.                else
  240.                {
  241.                   if(eval("\x01") != 318)
  242.                   {
  243.                      if(eval("\x01") == 943)
  244.                      {
  245.                         addr3308:
  246.                         set("\x01",eval("\x01") - 431);
  247.                         if(!eval(".∩┐╜∩┐╜∩┐╜AUI")["<▌û∩┐╜∩┐╜\'∩┐╜"])
  248.                         {
  249.                            eval(".∩┐╜∩┐╜∩┐╜AUI")["<▌û∩┐╜∩┐╜\'∩┐╜"] = new ┬º∩┐╜\x15∩┐╜V∩┐╜∩┐╜┬º();
  250.                         }
  251.                         ┬º┬ºpop();
  252.                         if(!eval(".∩┐╜∩┐╜∩┐╜AUI")["<▌û∩┐╜∩┐╜\'∩┐╜"][",e\\∩┐╜G+"])
  253.                         {
  254.                            eval("<▌û∩┐╜∩┐╜\'∩┐╜")[",e\\∩┐╜G+"] extends eval(┬º┬ºconstant(12));
  255.                            var _loc2_ = eval("<▌û∩┐╜∩┐╜\'∩┐╜")[",e\\∩┐╜G+"] = function()
  256.                            {
  257.                               super();
  258.                               this["∩┐╜y"](25);
  259.                               this[┬º┬ºconstant(5)](5);
  260.                               this[┬º┬ºconstant(8)](eval(┬º┬ºconstant(6))[┬º┬ºconstant(7)]);
  261.                               this[┬º┬ºconstant(9)](1);
  262.                               this[┬º┬ºconstant(10)](3);
  263.                               this[┬º┬ºconstant(11)](7);
  264.                               this[┬º┬ºconstant(14)](2.5 * eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)]);
  265.                               this[┬º┬ºconstant(15)](13000);
  266.                               this[┬º┬ºconstant(16)](40000);
  267.                               this[┬º┬ºconstant(17)](67000);
  268.                               this[┬º┬ºconstant(18)]();
  269.                            }[┬º┬ºconstant(19)];
  270.                            ┬º┬ºpush(┬º┬ºconstant(20)(eval("<▌û∩┐╜∩┐╜\'∩┐╜")[",e\\∩┐╜G+"][┬º┬ºconstant(19)],null,1));
  271.                         }
  272.                         ┬º┬ºpop();
  273.                         break loop0;
  274.                      }
  275.                      if(eval("\x01") == 512)
  276.                      {
  277.                         set("\x01",eval("\x01") - 512);
  278.                         break loop0;
  279.                      }
  280.                      break loop0;
  281.                   }
  282.                   set("\x01",eval("\x01") - 243);
  283.                }
  284.             }
  285.          }
  286.          while(true)
  287.          {
  288.             if(eval("\x01") == 951)
  289.             {
  290.                set("\x01",eval("\x01") - 391);
  291.                ┬º┬ºpush(true);
  292.                continue;
  293.             }
  294.             if(eval("\x01") == 153)
  295.             {
  296.                set("\x01",eval("\x01") + 76);
  297.                continue;
  298.             }
  299.             if(eval("\x01") == 353)
  300.             {
  301.                set("\x01",eval("\x01") - 6);
  302.                ┬º┬ºpush(true);
  303.                continue;
  304.             }
  305.             if(eval("\x01") == 699)
  306.             {
  307.                set("\x01",eval("\x01") - 346);
  308.                continue;
  309.             }
  310.             if(eval("\x01") == 347)
  311.             {
  312.                set("\x01",eval("\x01") - 87);
  313.                if(┬º┬ºpop())
  314.                {
  315.                   set("\x01",eval("\x01") + 253);
  316.                }
  317.                continue;
  318.             }
  319.             if(eval("\x01") == 141)
  320.             {
  321.                set("\x01",eval("\x01") + 796);
  322.                addr1653:
  323.                if(┬º┬ºpop() != 883)
  324.                {
  325.                   if(eval("\x01") == 936)
  326.                   {
  327.                      set("\x01",eval("\x01") - 124);
  328.                      if(!┬º┬ºpop())
  329.                      {
  330.                         addr1025:
  331.                         if(eval("\x01") == 894)
  332.                         {
  333.                            set("\x01",eval("\x01") - 447);
  334.                            ┬º┬ºgoto(addr1025);
  335.                            ┬º┬ºpush(true);
  336.                         }
  337.                         if(eval("\x01") == 388)
  338.                         {
  339.                            set("\x01",eval("\x01") + 419);
  340.                            ┬º┬ºgoto(addr1025);
  341.                         }
  342.                         if(eval("\x01") == 850)
  343.                         {
  344.                            set("\x01",eval("\x01") - 210);
  345.                            if(!┬º┬ºpop())
  346.                            {
  347.                               addr1076:
  348.                               ┬º┬ºgoto(addr1025);
  349.                            }
  350.                            set("\x01",eval("\x01") - 564);
  351.                            ┬º┬ºgoto(addr1076);
  352.                         }
  353.                         if(eval("\x01") == 447)
  354.                         {
  355.                            set("\x01",eval("\x01") + 320);
  356.                            if(!┬º┬ºpop())
  357.                            {
  358.                               addr1097:
  359.                               ┬º┬ºgoto(addr1025);
  360.                            }
  361.                            set("\x01",eval("\x01") - 641);
  362.                            ┬º┬ºgoto(addr1097);
  363.                         }
  364.                         if(eval("\x01") == 126)
  365.                         {
  366.                            set("\x01",eval("\x01") + 369);
  367.                            ┬º┬ºgoto(addr1025);
  368.                         }
  369.                         if(eval("\x01") == 839)
  370.                         {
  371.                            set("\x01",eval("\x01") + 119);
  372.                            ┬º┬ºgoto(addr1025);
  373.                         }
  374.                         if(eval("\x01") == 274)
  375.                         {
  376.                            set("\x01",eval("\x01") - 83);
  377.                            ┬º┬ºgoto(addr1025);
  378.                            ┬º┬ºpush(true);
  379.                         }
  380.                         if(eval("\x01") == 696)
  381.                         {
  382.                            set("\x01",eval("\x01") - 347);
  383.                            ┬º┬ºgoto(addr1025);
  384.                         }
  385.                         if(eval("\x01") == 846)
  386.                         {
  387.                            set("\x01",eval("\x01") - 628);
  388.                            if(!┬º┬ºpop())
  389.                            {
  390.                               addr1174:
  391.                               ┬º┬ºgoto(addr1025);
  392.                            }
  393.                            set("\x01",eval("\x01") + 138);
  394.                            ┬º┬ºgoto(addr1174);
  395.                         }
  396.                         if(eval("\x01") == 958)
  397.                         {
  398.                            set("\x01",eval("\x01") - 108);
  399.                            ┬º┬ºgoto(addr1025);
  400.                            ┬º┬ºpush(true);
  401.                         }
  402.                         if(eval("\x01") == 703)
  403.                         {
  404.                            set("\x01",eval("\x01") + 169);
  405.                            ┬º┬ºgoto(addr1025);
  406.                            ┬º┬ºpush(true);
  407.                         }
  408.                         if(eval("\x01") == 397)
  409.                         {
  410.                            set("\x01",eval("\x01") + 277);
  411.                            ┬º┬ºgoto(addr1025);
  412.                         }
  413.                         if(eval("\x01") != 256)
  414.                         {
  415.                            if(eval("\x01") != 640)
  416.                            {
  417.                               if(eval("\x01") == 76)
  418.                               {
  419.                                  set("\x01",eval("\x01") + 601);
  420.                                  ┬º┬ºgoto(addr1025);
  421.                               }
  422.                               if(eval("\x01") != 714)
  423.                               {
  424.                                  if(eval("\x01") == 45)
  425.                                  {
  426.                                     set("\x01",eval("\x01") + 913);
  427.                                     ┬º┬ºgoto(addr1025);
  428.                                  }
  429.                                  if(eval("\x01") != 812)
  430.                                  {
  431.                                     if(eval("\x01") == 874)
  432.                                     {
  433.                                        set("\x01",eval("\x01") - 379);
  434.                                        ┬º┬ºgoto(addr1025);
  435.                                     }
  436.                                     if(eval("\x01") == 677)
  437.                                     {
  438.                                        set("\x01",eval("\x01") - 47);
  439.                                        ┬º┬ºgoto(addr1025);
  440.                                        ┬º┬ºpush(true);
  441.                                     }
  442.                                     if(eval("\x01") == 177)
  443.                                     {
  444.                                        set("\x01",eval("\x01") + 79);
  445.                                        if(!┬º┬ºpop())
  446.                                        {
  447.                                           addr1344:
  448.                                           ┬º┬ºgoto(addr1025);
  449.                                        }
  450.                                        set("\x01",eval("\x01") + 637);
  451.                                        ┬º┬ºgoto(addr1344);
  452.                                     }
  453.                                     if(eval("\x01") == 658)
  454.                                     {
  455.                                        set("\x01",eval("\x01") - 309);
  456.                                        ┬º┬ºgoto(addr1025);
  457.                                     }
  458.                                     if(eval("\x01") == 523)
  459.                                     {
  460.                                        set("\x01",eval("\x01") - 249);
  461.                                        ┬º┬ºgoto(addr1025);
  462.                                     }
  463.                                     if(eval("\x01") == 501)
  464.                                     {
  465.                                        set("\x01",eval("\x01") + 364);
  466.                                        ┬º┬ºgoto(addr1025);
  467.                                     }
  468.                                     if(eval("\x01") != 218)
  469.                                     {
  470.                                        if(eval("\x01") == 865)
  471.                                        {
  472.                                           set("\x01",eval("\x01") - 439);
  473.                                           ┬º┬ºgoto(addr1025);
  474.                                        }
  475.                                        if(eval("\x01") == 659)
  476.                                        {
  477.                                           set("\x01",eval("\x01") - 482);
  478.                                           ┬º┬ºgoto(addr1025);
  479.                                           ┬º┬ºpush(true);
  480.                                        }
  481.                                        if(eval("\x01") == 30)
  482.                                        {
  483.                                           set("\x01",eval("\x01") + 647);
  484.                                           ┬º┬ºgoto(addr1025);
  485.                                        }
  486.                                        if(eval("\x01") == 872)
  487.                                        {
  488.                                           set("\x01",eval("\x01") - 121);
  489.                                           if(!┬º┬ºpop())
  490.                                           {
  491.                                              addr1460:
  492.                                              ┬º┬ºgoto(addr1025);
  493.                                           }
  494.                                           set("\x01",eval("\x01") - 93);
  495.                                           ┬º┬ºgoto(addr1460);
  496.                                        }
  497.                                        if(eval("\x01") == 630)
  498.                                        {
  499.                                           set("\x01",eval("\x01") + 200);
  500.                                           if(!┬º┬ºpop())
  501.                                           {
  502.                                              addr1481:
  503.                                              ┬º┬ºgoto(addr1025);
  504.                                           }
  505.                                           set("\x01",eval("\x01") - 329);
  506.                                           ┬º┬ºgoto(addr1481);
  507.                                        }
  508.                                        if(eval("\x01") != 830)
  509.                                        {
  510.                                           if(eval("\x01") == 893)
  511.                                           {
  512.                                              set("\x01",eval("\x01") - 619);
  513.                                              ┬º┬ºgoto(addr1025);
  514.                                           }
  515.                                           if(eval("\x01") == 495)
  516.                                           {
  517.                                              set("\x01",eval("\x01") + 351);
  518.                                              ┬º┬ºgoto(addr1025);
  519.                                              ┬º┬ºpush(true);
  520.                                           }
  521.                                           if(eval("\x01") != 549)
  522.                                           {
  523.                                              if(eval("\x01") == 191)
  524.                                              {
  525.                                                 set("\x01",eval("\x01") + 358);
  526.                                                 if(!┬º┬ºpop())
  527.                                                 {
  528.                                                    addr1555:
  529.                                                    ┬º┬ºgoto(addr1025);
  530.                                                 }
  531.                                                 set("\x01",eval("\x01") - 198);
  532.                                                 ┬º┬ºgoto(addr1555);
  533.                                              }
  534.                                              if(eval("\x01") != 426)
  535.                                              {
  536.                                                 if(eval("\x01") == 595)
  537.                                                 {
  538.                                                    set("\x01",eval("\x01") + 64);
  539.                                                    ┬º┬ºgoto(addr1025);
  540.                                                 }
  541.                                                 if(eval("\x01") == 351)
  542.                                                 {
  543.                                                    set("\x01",eval("\x01") + 456);
  544.                                                    ┬º┬ºgoto(addr1025);
  545.                                                 }
  546.                                                 if(eval("\x01") == 356)
  547.                                                 {
  548.                                                    set("\x01",eval("\x01") + 303);
  549.                                                    ┬º┬ºgoto(addr1025);
  550.                                                 }
  551.                                                 if(eval("\x01") == 349)
  552.                                                 {
  553.                                                    set("\x01",eval("\x01") + 587);
  554.                                                    ┬º┬ºgoto(addr1025);
  555.                                                    ┬º┬ºpush(true);
  556.                                                 }
  557.                                                 if(eval("\x01") == 902)
  558.                                                 {
  559.                                                    set("\x01",eval("\x01") - 37);
  560.                                                    ┬º┬ºgoto(addr1025);
  561.                                                 }
  562.                                                 if(eval("\x01") != 751)
  563.                                                 {
  564.                                                    ┬º┬ºgoto(addr1653);
  565.                                                    ┬º┬ºpush(eval("\x01"));
  566.                                                 }
  567.                                                 set("\x01",eval("\x01") - 93);
  568.                                                 break loop0;
  569.                                              }
  570.                                              set("\x01",eval("\x01") + 457);
  571.                                              if(!eval("∩┐╜∩┐╜").VF)
  572.                                              {
  573.                                                 eval("∩┐╜∩┐╜").VF = new ┬º'\x1d∩┐╜\n┬º();
  574.                                              }
  575.                                              ┬º┬ºpop();
  576.                                              if(!eval("∩┐╜∩┐╜").VF[┬º┬ºconstant(3)])
  577.                                              {
  578.                                                 VF[┬º┬ºconstant(3)] extends eval(┬º┬ºconstant(12));
  579.                                                 _loc2_ = VF[┬º┬ºconstant(3)] = function()
  580.                                                 {
  581.                                                    super();
  582.                                                    this[┬º┬ºconstant(4)](16);
  583.                                                    this[┬º┬ºconstant(5)](16);
  584.                                                    this[┬º┬ºconstant(8)](eval(┬º┬ºconstant(6))[┬º┬ºconstant(7)]);
  585.                                                    this[┬º┬ºconstant(9)](1);
  586.                                                    this[┬º┬ºconstant(10)](9);
  587.                                                    this[┬º┬ºconstant(11)](9);
  588.                                                    this[┬º┬ºconstant(14)](2.5 * eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)]);
  589.                                                    this[┬º┬ºconstant(15)](16000);
  590.                                                    this[┬º┬ºconstant(16)](36000);
  591.                                                    this[┬º┬ºconstant(17)](56000);
  592.                                                    this[┬º┬ºconstant(18)]();
  593.                                                 }[┬º┬ºconstant(19)];
  594.                                                 ┬º┬ºpush(┬º┬ºconstant(20)(VF[┬º┬ºconstant(3)][┬º┬ºconstant(19)],null,1));
  595.                                              }
  596.                                              ┬º┬ºpop();
  597.                                              break loop0;
  598.                                           }
  599.                                           set("\x01",eval("\x01") - 198);
  600.                                           break loop0;
  601.                                        }
  602.                                        set("\x01",eval("\x01") - 329);
  603.                                        prevFrame();
  604.                                        break loop0;
  605.                                     }
  606.                                     set("\x01",eval("\x01") + 138);
  607.                                     addr218:
  608.                                     if(┬º┬ºpop() == ┬º┬ºpop())
  609.                                     {
  610.                                        set("\x01",eval("\x01") - 248);
  611.                                        addr114:
  612.                                        if(eval("\x01") == 465)
  613.                                        {
  614.                                           set("\x01",eval("\x01") - 335);
  615.                                           ┬º┬ºgoto(addr114);
  616.                                           ┬º┬ºpush(true);
  617.                                        }
  618.                                        if(eval("\x01") == 968)
  619.                                        {
  620.                                           set("\x01",eval("\x01") - 229);
  621.                                           if(!┬º┬ºpop())
  622.                                           {
  623.                                              addr151:
  624.                                              ┬º┬ºgoto(addr114);
  625.                                           }
  626.                                           set("\x01",eval("\x01") - 655);
  627.                                           ┬º┬ºgoto(addr151);
  628.                                        }
  629.                                        if(eval("\x01") == 778)
  630.                                        {
  631.                                           set("\x01",eval("\x01") + 161);
  632.                                           ┬º┬ºgoto(addr114);
  633.                                           ┬º┬ºpush(true);
  634.                                        }
  635.                                        if(eval("\x01") == 768)
  636.                                        {
  637.                                           set("\x01",eval("\x01") - 421);
  638.                                           ┬º┬ºgoto(addr114);
  639.                                        }
  640.                                        if(eval("\x01") == 225)
  641.                                        {
  642.                                           set("\x01",eval("\x01") - 147);
  643.                                           ┬º┬ºgoto(addr114);
  644.                                        }
  645.                                        if(eval("\x01") == 158)
  646.                                        {
  647.                                           set("\x01",eval("\x01") + 72);
  648.                                           if(!┬º┬ºpop())
  649.                                           {
  650.                                              addr214:
  651.                                              ┬º┬ºgoto(addr114);
  652.                                           }
  653.                                           set("\x01",eval("\x01") - 7);
  654.                                           ┬º┬ºgoto(addr214);
  655.                                        }
  656.                                        ┬º┬ºgoto(addr218);
  657.                                        ┬º┬ºpush(eval("\x01"));
  658.                                        ┬º┬ºpush(957);
  659.                                     }
  660.                                     if(eval("\x01") != 230)
  661.                                     {
  662.                                        if(eval("\x01") != 686)
  663.                                        {
  664.                                           if(eval("\x01") == 917)
  665.                                           {
  666.                                              set("\x01",eval("\x01") - 156);
  667.                                              ┬º┬ºgoto(addr114);
  668.                                              ┬º┬ºpush(true);
  669.                                           }
  670.                                           if(eval("\x01") != 172)
  671.                                           {
  672.                                              if(eval("\x01") != 168)
  673.                                              {
  674.                                                 if(eval("\x01") == 749)
  675.                                                 {
  676.                                                    set("\x01",eval("\x01") - 485);
  677.                                                    ┬º┬ºgoto(addr114);
  678.                                                    ┬º┬ºpush(true);
  679.                                                 }
  680.                                                 if(eval("\x01") == 79)
  681.                                                 {
  682.                                                    set("\x01",eval("\x01") + 7);
  683.                                                    ┬º┬ºgoto(addr114);
  684.                                                 }
  685.                                                 if(eval("\x01") == 130)
  686.                                                 {
  687.                                                    set("\x01",eval("\x01") + 38);
  688.                                                    if(!┬º┬ºpop())
  689.                                                    {
  690.                                                       addr343:
  691.                                                       ┬º┬ºgoto(addr114);
  692.                                                    }
  693.                                                    set("\x01",eval("\x01") + 162);
  694.                                                    ┬º┬ºgoto(addr343);
  695.                                                 }
  696.                                                 if(eval("\x01") == 152)
  697.                                                 {
  698.                                                    set("\x01",eval("\x01") + 534);
  699.                                                    if(!┬º┬ºpop())
  700.                                                    {
  701.                                                       addr364:
  702.                                                       ┬º┬ºgoto(addr114);
  703.                                                    }
  704.                                                    set("\x01",eval("\x01") - 609);
  705.                                                    ┬º┬ºgoto(addr364);
  706.                                                 }
  707.                                                 if(eval("\x01") != 318)
  708.                                                 {
  709.                                                    if(eval("\x01") != 613)
  710.                                                    {
  711.                                                       if(eval("\x01") != 296)
  712.                                                       {
  713.                                                          if(eval("\x01") == 95)
  714.                                                          {
  715.                                                             set("\x01",eval("\x01") + 252);
  716.                                                             ┬º┬ºgoto(addr114);
  717.                                                          }
  718.                                                          if(eval("\x01") == 78)
  719.                                                          {
  720.                                                             set("\x01",eval("\x01") + 74);
  721.                                                             ┬º┬ºgoto(addr114);
  722.                                                             ┬º┬ºpush(true);
  723.                                                          }
  724.                                                          if(eval("\x01") == 17)
  725.                                                          {
  726.                                                             set("\x01",eval("\x01") + 314);
  727.                                                             ┬º┬ºgoto(addr114);
  728.                                                          }
  729.                                                          if(eval("\x01") != 532)
  730.                                                          {
  731.                                                             if(eval("\x01") == 970)
  732.                                                             {
  733.                                                                set("\x01",eval("\x01") - 53);
  734.                                                                ┬º┬ºgoto(addr114);
  735.                                                             }
  736.                                                             if(eval("\x01") == 330)
  737.                                                             {
  738.                                                                set("\x01",eval("\x01") + 448);
  739.                                                                ┬º┬ºgoto(addr114);
  740.                                                             }
  741.                                                             if(eval("\x01") == 761)
  742.                                                             {
  743.                                                                set("\x01",eval("\x01") - 589);
  744.                                                                if(!┬º┬ºpop())
  745.                                                                {
  746.                                                                   addr507:
  747.                                                                   ┬º┬ºgoto(addr114);
  748.                                                                }
  749.                                                                set("\x01",eval("\x01") - 77);
  750.                                                                ┬º┬ºgoto(addr507);
  751.                                                             }
  752.                                                             if(eval("\x01") == 264)
  753.                                                             {
  754.                                                                set("\x01",eval("\x01") + 268);
  755.                                                                if(!┬º┬ºpop())
  756.                                                                {
  757.                                                                   addr528:
  758.                                                                   ┬º┬ºgoto(addr114);
  759.                                                                }
  760.                                                                set("\x01",eval("\x01") - 515);
  761.                                                                ┬º┬ºgoto(addr528);
  762.                                                             }
  763.                                                             if(eval("\x01") == 703)
  764.                                                             {
  765.                                                                set("\x01",eval("\x01") + 214);
  766.                                                                ┬º┬ºgoto(addr114);
  767.                                                             }
  768.                                                             if(eval("\x01") == 460)
  769.                                                             {
  770.                                                                set("\x01",eval("\x01") + 324);
  771.                                                                ┬º┬ºgoto(addr114);
  772.                                                             }
  773.                                                             if(eval("\x01") != 25)
  774.                                                             {
  775.                                                                if(eval("\x01") == 241)
  776.                                                                {
  777.                                                                   set("\x01",eval("\x01") + 537);
  778.                                                                   ┬º┬ºgoto(addr114);
  779.                                                                }
  780.                                                                if(eval("\x01") == 643)
  781.                                                                {
  782.                                                                   set("\x01",eval("\x01") + 314);
  783.                                                                   ┬º┬ºgoto(addr114);
  784.                                                                }
  785.                                                                if(eval("\x01") == 488)
  786.                                                                {
  787.                                                                   set("\x01",eval("\x01") - 463);
  788.                                                                   if(!┬º┬ºpop())
  789.                                                                   {
  790.                                                                      addr618:
  791.                                                                      ┬º┬ºgoto(addr114);
  792.                                                                   }
  793.                                                                   set("\x01",eval("\x01") + 390);
  794.                                                                   ┬º┬ºgoto(addr618);
  795.                                                                }
  796.                                                                if(eval("\x01") == 77)
  797.                                                                {
  798.                                                                   set("\x01",eval("\x01") + 707);
  799.                                                                   ┬º┬ºgoto(addr114);
  800.                                                                }
  801.                                                                if(eval("\x01") == 415)
  802.                                                                {
  803.                                                                   set("\x01",eval("\x01") - 329);
  804.                                                                   ┬º┬ºgoto(addr114);
  805.                                                                }
  806.                                                                if(eval("\x01") == 939)
  807.                                                                {
  808.                                                                   set("\x01",eval("\x01") - 643);
  809.                                                                   if(!┬º┬ºpop())
  810.                                                                   {
  811.                                                                      addr665:
  812.                                                                      ┬º┬ºgoto(addr114);
  813.                                                                   }
  814.                                                                   set("\x01",eval("\x01") + 674);
  815.                                                                   ┬º┬ºgoto(addr665);
  816.                                                                }
  817.                                                                if(eval("\x01") == 347)
  818.                                                                {
  819.                                                                   set("\x01",eval("\x01") - 189);
  820.                                                                   ┬º┬ºgoto(addr114);
  821.                                                                   ┬º┬ºpush(true);
  822.                                                                }
  823.                                                                if(eval("\x01") != 709)
  824.                                                                {
  825.                                                                   if(eval("\x01") == 807)
  826.                                                                   {
  827.                                                                      set("\x01",eval("\x01") - 58);
  828.                                                                      ┬º┬ºgoto(addr114);
  829.                                                                   }
  830.                                                                   if(eval("\x01") == 86)
  831.                                                                   {
  832.                                                                      set("\x01",eval("\x01") + 303);
  833.                                                                      ┬º┬ºgoto(addr114);
  834.                                                                      ┬º┬ºpush(true);
  835.                                                                   }
  836.                                                                   if(eval("\x01") == 223)
  837.                                                                   {
  838.                                                                      set("\x01",eval("\x01") - 145);
  839.                                                                      ┬º┬ºgoto(addr114);
  840.                                                                   }
  841.                                                                   if(eval("\x01") == 784)
  842.                                                                   {
  843.                                                                      set("\x01",eval("\x01") + 184);
  844.                                                                      ┬º┬ºgoto(addr114);
  845.                                                                      ┬º┬ºpush(true);
  846.                                                                   }
  847.                                                                   if(eval("\x01") != 739)
  848.                                                                   {
  849.                                                                      if(eval("\x01") == 84)
  850.                                                                      {
  851.                                                                         set("\x01",eval("\x01") + 570);
  852.                                                                         ┬º┬ºgoto(addr114);
  853.                                                                      }
  854.                                                                      if(eval("\x01") == 331)
  855.                                                                      {
  856.                                                                         set("\x01",eval("\x01") + 157);
  857.                                                                         ┬º┬ºgoto(addr114);
  858.                                                                         ┬º┬ºpush(true);
  859.                                                                      }
  860.                                                                      if(eval("\x01") == 758)
  861.                                                                      {
  862.                                                                         set("\x01",eval("\x01") - 104);
  863.                                                                         ┬º┬ºgoto(addr114);
  864.                                                                      }
  865.                                                                      if(eval("\x01") == 654)
  866.                                                                      {
  867.                                                                         set("\x01",eval("\x01") + 279);
  868.                                                                         ┬º┬ºgoto(addr114);
  869.                                                                         ┬º┬ºpush(true);
  870.                                                                      }
  871.                                                                      if(eval("\x01") == 933)
  872.                                                                      {
  873.                                                                         set("\x01",eval("\x01") - 615);
  874.                                                                         if(!┬º┬ºpop())
  875.                                                                         {
  876.                                                                            addr837:
  877.                                                                            ┬º┬ºgoto(addr114);
  878.                                                                         }
  879.                                                                         set("\x01",eval("\x01") + 209);
  880.                                                                         ┬º┬ºgoto(addr837);
  881.                                                                      }
  882.                                                                      if(eval("\x01") == 527)
  883.                                                                      {
  884.                                                                         set("\x01",eval("\x01") + 222);
  885.                                                                         ┬º┬ºgoto(addr114);
  886.                                                                      }
  887.                                                                      if(eval("\x01") == 834)
  888.                                                                      {
  889.                                                                         set("\x01",eval("\x01") - 503);
  890.                                                                         ┬º┬ºgoto(addr114);
  891.                                                                      }
  892.                                                                      if(eval("\x01") == 389)
  893.                                                                      {
  894.                                                                         set("\x01",eval("\x01") + 224);
  895.                                                                         if(!┬º┬ºpop())
  896.                                                                         {
  897.                                                                            addr885:
  898.                                                                            ┬º┬ºgoto(addr114);
  899.                                                                         }
  900.                                                                         set("\x01",eval("\x01") - 140);
  901.                                                                         ┬º┬ºgoto(addr885);
  902.                                                                      }
  903.                                                                      if(eval("\x01") == 473)
  904.                                                                      {
  905.                                                                         set("\x01",eval("\x01") + 484);
  906.                                                                         ┬º┬ºgoto(addr114);
  907.                                                                      }
  908.                                                                      if(eval("\x01") == 872)
  909.                                                                      {
  910.                                                                         set("\x01",eval("\x01") - 872);
  911.                                                                         break loop0;
  912.                                                                      }
  913.                                                                      break loop0;
  914.                                                                   }
  915.                                                                   set("\x01",eval("\x01") - 655);
  916.                                                                   ┬º┬ºpush(┬º┬ºpop() >>> (┬º┬ºpop() >>> ┬º┬ºpop()));
  917.                                                                   break loop0;
  918.                                                                }
  919.                                                                set("\x01",eval("\x01") + 163);
  920.                                                                if(!eval("∩┐╜∩┐╜\t\x14∩┐╜∩┐╜∩┐╜")["∩┐╜∩┐╜∩┐╜\f "])
  921.                                                                {
  922.                                                                   eval("∩┐╜∩┐╜\t\x14∩┐╜∩┐╜∩┐╜")["∩┐╜∩┐╜∩┐╜\f "] = new ╬«();
  923.                                                                }
  924.                                                                ┬º┬ºpop();
  925.                                                                if(!eval("∩┐╜∩┐╜\t\x14∩┐╜∩┐╜∩┐╜")["∩┐╜∩┐╜∩┐╜\f "]["∩┐╜5∩┐╜∩┐╜"])
  926.                                                                {
  927.                                                                   eval("∩┐╜∩┐╜∩┐╜\f ")["∩┐╜5∩┐╜∩┐╜"] extends eval(┬º┬ºconstant(12));
  928.                                                                   _loc2_ = eval("∩┐╜∩┐╜∩┐╜\f ")["∩┐╜5∩┐╜∩┐╜"] = function()
  929.                                                                   {
  930.                                                                      super();
  931.                                                                      this["+\x18O"](8);
  932.                                                                      this["%∩┐╜o∩┐╜9\r"](8);
  933.                                                                      this[┬º┬ºconstant(8)](eval(┬º┬ºconstant(6))[┬º┬ºconstant(7)]);
  934.                                                                      this[┬º┬ºconstant(9)](1);
  935.                                                                      this[┬º┬ºconstant(10)](4);
  936.                                                                      this[┬º┬ºconstant(11)](4);
  937.                                                                      this[┬º┬ºconstant(14)](2.5 * eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)]);
  938.                                                                      this[┬º┬ºconstant(15)](3000);
  939.                                                                      this[┬º┬ºconstant(16)](11000);
  940.                                                                      this[┬º┬ºconstant(17)](20000);
  941.                                                                      this[┬º┬ºconstant(18)]();
  942.                                                                   }[┬º┬ºconstant(19)];
  943.                                                                   ┬º┬ºpush(┬º┬ºconstant(20)(eval("∩┐╜∩┐╜∩┐╜\f ")["∩┐╜5∩┐╜∩┐╜"][┬º┬ºconstant(19)],null,1));
  944.                                                                }
  945.                                                                ┬º┬ºpop();
  946.                                                                break loop0;
  947.                                                             }
  948.                                                             set("\x01",eval("\x01") + 390);
  949.                                                             break loop0;
  950.                                                          }
  951.                                                          set("\x01",eval("\x01") - 515);
  952.                                                          break loop0;
  953.                                                       }
  954.                                                       set("\x01",eval("\x01") + 674);
  955.                                                       break loop0;
  956.                                                    }
  957.                                                    set("\x01",eval("\x01") - 140);
  958.                                                    break loop0;
  959.                                                 }
  960.                                                 set("\x01",eval("\x01") + 209);
  961.                                                 ┬º┬ºpush(┬º┬ºpop() == ┬º┬ºpop());
  962.                                                 break loop0;
  963.                                              }
  964.                                              set("\x01",eval("\x01") + 162);
  965.                                              break loop0;
  966.                                           }
  967.                                           set("\x01",eval("\x01") - 77);
  968.                                           break loop0;
  969.                                        }
  970.                                        set("\x01",eval("\x01") - 609);
  971.                                        break loop0;
  972.                                     }
  973.                                     set("\x01",eval("\x01") - 7);
  974.                                     break loop0;
  975.                                  }
  976.                                  set("\x01",eval("\x01") + 27);
  977.                                  prevFrame();
  978.                                  break loop0;
  979.                               }
  980.                               set("\x01",eval("\x01") - 308);
  981.                               break loop0;
  982.                            }
  983.                            set("\x01",eval("\x01") - 564);
  984.                            break loop0;
  985.                         }
  986.                         set("\x01",eval("\x01") + 637);
  987.                         ┬º┬ºpush(┬º┬ºpop()[┬º┬ºpop()]());
  988.                         break loop0;
  989.                         addr1684:
  990.                      }
  991.                      set("\x01",eval("\x01") + 27);
  992.                      ┬º┬ºgoto(addr1684);
  993.                   }
  994.                   if(eval("\x01") == 118)
  995.                   {
  996.                      set("\x01",eval("\x01") + 585);
  997.                      ┬º┬ºgoto(addr1025);
  998.                   }
  999.                   if(eval("\x01") == 406)
  1000.                   {
  1001.                      set("\x01",eval("\x01") + 297);
  1002.                      ┬º┬ºgoto(addr1025);
  1003.                   }
  1004.                   if(eval("\x01") != 767)
  1005.                   {
  1006.                      if(eval("\x01") == 807)
  1007.                      {
  1008.                         set("\x01",eval("\x01") - 5);
  1009.                         ┬º┬ºgoto(addr1025);
  1010.                         ┬º┬ºpush(true);
  1011.                      }
  1012.                      if(eval("\x01") == 749)
  1013.                      {
  1014.                         set("\x01",eval("\x01") - 35);
  1015.                         if(!┬º┬ºpop())
  1016.                         {
  1017.                            addr1759:
  1018.                            ┬º┬ºgoto(addr1025);
  1019.                         }
  1020.                         set("\x01",eval("\x01") - 308);
  1021.                         ┬º┬ºgoto(addr1759);
  1022.                      }
  1023.                      if(eval("\x01") == 802)
  1024.                      {
  1025.                         set("\x01",eval("\x01") - 649);
  1026.                         if(!┬º┬ºpop())
  1027.                         {
  1028.                            addr1780:
  1029.                            ┬º┬ºgoto(addr1025);
  1030.                         }
  1031.                         set("\x01",eval("\x01") + 244);
  1032.                         ┬º┬ºgoto(addr1780);
  1033.                      }
  1034.                      if(eval("\x01") != 153)
  1035.                      {
  1036.                         if(eval("\x01") == 674)
  1037.                         {
  1038.                            set("\x01",eval("\x01") + 75);
  1039.                            ┬º┬ºgoto(addr1025);
  1040.                            ┬º┬ºpush(true);
  1041.                         }
  1042.                         if(eval("\x01") == 429)
  1043.                         {
  1044.                            set("\x01",eval("\x01") + 245);
  1045.                            ┬º┬ºgoto(addr1025);
  1046.                         }
  1047.                         break loop0;
  1048.                      }
  1049.                      set("\x01",eval("\x01") + 244);
  1050.                      ┬º┬ºpush(┬º┬ºpop() * ┬º┬ºpop());
  1051.                      break loop0;
  1052.                   }
  1053.                   set("\x01",eval("\x01") - 641);
  1054.                   var _loc0_ = null;
  1055.                   ┬º┬ºpush(mbchr(_loc0_ = ┬º┬ºpop()));
  1056.                   break loop0;
  1057.                }
  1058.                set("\x01",eval("\x01") - 883);
  1059.                break loop0;
  1060.             }
  1061.             if(eval("\x01") == 813)
  1062.             {
  1063.                set("\x01",eval("\x01") - 385);
  1064.                break loop0;
  1065.             }
  1066.             if(eval("\x01") == 187)
  1067.             {
  1068.                set("\x01",eval("\x01") + 544);
  1069.                continue;
  1070.             }
  1071.             if(eval("\x01") == 126)
  1072.             {
  1073.                set("\x01",eval("\x01") + 498);
  1074.                ┬º┬ºpush(true);
  1075.                continue;
  1076.             }
  1077.             if(eval("\x01") == 745)
  1078.             {
  1079.                set("\x01",eval("\x01") + 198);
  1080.                continue;
  1081.             }
  1082.             if(eval("\x01") == 562)
  1083.             {
  1084.                set("\x01",eval("\x01") - 436);
  1085.                continue;
  1086.             }
  1087.             if(eval("\x01") == 120)
  1088.             {
  1089.                set("\x01",eval("\x01") + 21);
  1090.                if(┬º┬ºpop())
  1091.                {
  1092.                   set("\x01",eval("\x01") + 796);
  1093.                }
  1094.                continue;
  1095.             }
  1096.             if(eval("\x01") == 209)
  1097.             {
  1098.                set("\x01",eval("\x01") + 769);
  1099.                if(┬º┬ºpop())
  1100.                {
  1101.                   set("\x01",eval("\x01") - 170);
  1102.                }
  1103.                continue;
  1104.             }
  1105.             if(eval("\x01") == 916)
  1106.             {
  1107.                set("\x01",eval("\x01") - 563);
  1108.                continue;
  1109.             }
  1110.             if(eval("\x01") == 264)
  1111.             {
  1112.                set("\x01",eval("\x01") + 716);
  1113.                if(┬º┬ºpop())
  1114.                {
  1115.                   set("\x01",eval("\x01") - 56);
  1116.                }
  1117.                continue;
  1118.             }
  1119.             if(eval("\x01") == 492)
  1120.             {
  1121.                set("\x01",eval("\x01") + 321);
  1122.                if(┬º┬ºpop())
  1123.                {
  1124.                   set("\x01",eval("\x01") - 385);
  1125.                }
  1126.                continue;
  1127.             }
  1128.             if(eval("\x01") == 147)
  1129.             {
  1130.                set("\x01",eval("\x01") + 415);
  1131.                break loop0;
  1132.             }
  1133.             if(eval("\x01") == 463)
  1134.             {
  1135.                set("\x01",eval("\x01") + 453);
  1136.                ┬º┬ºpop() extends ┬º┬ºpop() instanceof (┬º┬ºpop() | ┬º┬ºpop()[┬º┬ºpop() >>> ┬º┬ºpop()]);
  1137.                ┬º┬ºpush(┬º┬ºpop() >>> ┬º┬ºpop());
  1138.                break loop0;
  1139.             }
  1140.             if(eval("\x01") == 996)
  1141.             {
  1142.                set("\x01",eval("\x01") - 870);
  1143.                continue;
  1144.             }
  1145.             if(eval("\x01") == 260)
  1146.             {
  1147.                set("\x01",eval("\x01") + 253);
  1148.                toggleHighQuality();
  1149.                ┬º┬ºpop()[┬º┬ºpop() + ┬º┬ºpop()]();
  1150.                (eval("∩┐╜∩┐╜∩┐╜\f ")["∩┐╜5∩┐╜∩┐╜"] = function()
  1151.                {
  1152.                   super();
  1153.                   this["+\x18O"](8);
  1154.                   this["%∩┐╜o∩┐╜9\r"](8);
  1155.                   this[┬º┬ºconstant(8)](eval(┬º┬ºconstant(6))[┬º┬ºconstant(7)]);
  1156.                   this[┬º┬ºconstant(9)](1);
  1157.                   this[┬º┬ºconstant(10)](4);
  1158.                   this[┬º┬ºconstant(11)](4);
  1159.                   this[┬º┬ºconstant(14)](2.5 * eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)]);
  1160.                   this[┬º┬ºconstant(15)](3000);
  1161.                   this[┬º┬ºconstant(16)](11000);
  1162.                   this[┬º┬ºconstant(17)](20000);
  1163.                   this[┬º┬ºconstant(18)]();
  1164.                })[┬º┬ºconstant(11)](2);
  1165.                (eval("∩┐╜∩┐╜∩┐╜\f ")["∩┐╜5∩┐╜∩┐╜"] = function()
  1166.                {
  1167.                   super();
  1168.                   this["+\x18O"](8);
  1169.                   this["%∩┐╜o∩┐╜9\r"](8);
  1170.                   this[┬º┬ºconstant(8)](eval(┬º┬ºconstant(6))[┬º┬ºconstant(7)]);
  1171.                   this[┬º┬ºconstant(9)](1);
  1172.                   this[┬º┬ºconstant(10)](4);
  1173.                   this[┬º┬ºconstant(11)](4);
  1174.                   this[┬º┬ºconstant(14)](2.5 * eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)]);
  1175.                   this[┬º┬ºconstant(15)](3000);
  1176.                   this[┬º┬ºconstant(16)](11000);
  1177.                   this[┬º┬ºconstant(17)](20000);
  1178.                   this[┬º┬ºconstant(18)]();
  1179.                })[┬º┬ºconstant(14)](2.5 * eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)]);
  1180.                (eval("∩┐╜∩┐╜∩┐╜\f ")["∩┐╜5∩┐╜∩┐╜"] = function()
  1181.                {
  1182.                   super();
  1183.                   this["+\x18O"](8);
  1184.                   this["%∩┐╜o∩┐╜9\r"](8);
  1185.                   this[┬º┬ºconstant(8)](eval(┬º┬ºconstant(6))[┬º┬ºconstant(7)]);
  1186.                   this[┬º┬ºconstant(9)](1);
  1187.                   this[┬º┬ºconstant(10)](4);
  1188.                   this[┬º┬ºconstant(11)](4);
  1189.                   this[┬º┬ºconstant(14)](2.5 * eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)]);
  1190.                   this[┬º┬ºconstant(15)](3000);
  1191.                   this[┬º┬ºconstant(16)](11000);
  1192.                   this[┬º┬ºconstant(17)](20000);
  1193.                   this[┬º┬ºconstant(18)]();
  1194.                })[┬º┬ºconstant(15)](4000);
  1195.                (eval("∩┐╜∩┐╜∩┐╜\f ")["∩┐╜5∩┐╜∩┐╜"] = function()
  1196.                {
  1197.                   super();
  1198.                   this["+\x18O"](8);
  1199.                   this["%∩┐╜o∩┐╜9\r"](8);
  1200.                   this[┬º┬ºconstant(8)](eval(┬º┬ºconstant(6))[┬º┬ºconstant(7)]);
  1201.                   this[┬º┬ºconstant(9)](1);
  1202.                   this[┬º┬ºconstant(10)](4);
  1203.                   this[┬º┬ºconstant(11)](4);
  1204.                   this[┬º┬ºconstant(14)](2.5 * eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)]);
  1205.                   this[┬º┬ºconstant(15)](3000);
  1206.                   this[┬º┬ºconstant(16)](11000);
  1207.                   this[┬º┬ºconstant(17)](20000);
  1208.                   this[┬º┬ºconstant(18)]();
  1209.                })[┬º┬ºconstant(16)](15000);
  1210.                (eval("∩┐╜∩┐╜∩┐╜\f ")["∩┐╜5∩┐╜∩┐╜"] = function()
  1211.                {
  1212.                   super();
  1213.                   this["+\x18O"](8);
  1214.                   this["%∩┐╜o∩┐╜9\r"](8);
  1215.                   this[┬º┬ºconstant(8)](eval(┬º┬ºconstant(6))[┬º┬ºconstant(7)]);
  1216.                   this[┬º┬ºconstant(9)](1);
  1217.                   this[┬º┬ºconstant(10)](4);
  1218.                   this[┬º┬ºconstant(11)](4);
  1219.                   this[┬º┬ºconstant(14)](2.5 * eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)]);
  1220.                   this[┬º┬ºconstant(15)](3000);
  1221.                   this[┬º┬ºconstant(16)](11000);
  1222.                   this[┬º┬ºconstant(17)](20000);
  1223.                   this[┬º┬ºconstant(18)]();
  1224.                })[┬º┬ºconstant(17)](26000);
  1225.                (eval("∩┐╜∩┐╜∩┐╜\f ")["∩┐╜5∩┐╜∩┐╜"] = function()
  1226.                {
  1227.                   super();
  1228.                   this["+\x18O"](8);
  1229.                   this["%∩┐╜o∩┐╜9\r"](8);
  1230.                   this[┬º┬ºconstant(8)](eval(┬º┬ºconstant(6))[┬º┬ºconstant(7)]);
  1231.                   this[┬º┬ºconstant(9)](1);
  1232.                   this[┬º┬ºconstant(10)](4);
  1233.                   this[┬º┬ºconstant(11)](4);
  1234.                   this[┬º┬ºconstant(14)](2.5 * eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)]);
  1235.                   this[┬º┬ºconstant(15)](3000);
  1236.                   this[┬º┬ºconstant(16)](11000);
  1237.                   this[┬º┬ºconstant(17)](20000);
  1238.                   this[┬º┬ºconstant(18)]();
  1239.                })[┬º┬ºconstant(18)]();
  1240.                addr2479:
  1241.                eval("2∩┐╜/∩┐╜O∩┐╜")["\x1c∩┐╜aW∩┐╜∩┐╜S∩┐╜"] extends eval(┬º┬ºconstant(12));
  1242.                _loc2_ = ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop()[┬º┬ºconstant(19)];
  1243.                ┬º┬ºconstant(20)(eval("y∩┐╜∩┐╜∩┐╜∩┐╜")["\x1c∩┐╜aW∩┐╜∩┐╜S∩┐╜"][┬º┬ºconstant(19)],null,1);
  1244.                break loop0;
  1245.             }
  1246.             if(eval("\x01") == 560)
  1247.             {
  1248.                set("\x01",eval("\x01") - 413);
  1249.                if(┬º┬ºpop())
  1250.                {
  1251.                   set("\x01",eval("\x01") + 415);
  1252.                }
  1253.                continue;
  1254.             }
  1255.             if(eval("\x01") == 731)
  1256.             {
  1257.                set("\x01",eval("\x01") - 467);
  1258.                ┬º┬ºpush(true);
  1259.                continue;
  1260.             }
  1261.             if(eval("\x01") == 624)
  1262.             {
  1263.                set("\x01",eval("\x01") + 193);
  1264.                if(┬º┬ºpop())
  1265.                {
  1266.                   set("\x01",eval("\x01") + 40);
  1267.                }
  1268.                continue;
  1269.             }
  1270.             if(eval("\x01") == 455)
  1271.             {
  1272.                set("\x01",eval("\x01") + 369);
  1273.                continue;
  1274.             }
  1275.             if(eval("\x01") == 513)
  1276.             {
  1277.                set("\x01",eval("\x01") + 218);
  1278.                continue;
  1279.             }
  1280.             if(eval("\x01") == 857)
  1281.             {
  1282.                set("\x01",eval("\x01") - 33);
  1283.                continue;
  1284.             }
  1285.             if(eval("\x01") == 980)
  1286.             {
  1287.                set("\x01",eval("\x01") - 56);
  1288.                set(┬º┬ºpop(),┬º┬ºpop() - 62);
  1289.                addr1950:
  1290.                set(┬º┬ºpop(),eval("\x01") - 751);
  1291.                ┬º┬ºpush(true);
  1292.                if(eval("\x01") == 827)
  1293.                {
  1294.                   ┬º┬ºgoto(addr1950);
  1295.                   ┬º┬ºpush("\x01");
  1296.                }
  1297.                if(eval("\x01") != 917)
  1298.                {
  1299.                   if(eval("\x01") == 76)
  1300.                   {
  1301.                      set("\x01",eval("\x01") + 887);
  1302.                      if(!┬º┬ºpop())
  1303.                      {
  1304.                         addr1990:
  1305.                         ┬º┬ºgoto(addr1950);
  1306.                      }
  1307.                      set("\x01",eval("\x01") - 701);
  1308.                      ┬º┬ºgoto(addr1990);
  1309.                   }
  1310.                   if(eval("\x01") == 91)
  1311.                   {
  1312.                      set("\x01",eval("\x01") + 298);
  1313.                      ┬º┬ºgoto(addr1950);
  1314.                   }
  1315.                   if(eval("\x01") == 156)
  1316.                   {
  1317.                      set("\x01",eval("\x01") + 761);
  1318.                      if(!┬º┬ºpop())
  1319.                      {
  1320.                         addr2025:
  1321.                         ┬º┬ºgoto(addr1950);
  1322.                      }
  1323.                      set("\x01",eval("\x01") - 712);
  1324.                      ┬º┬ºgoto(addr2025);
  1325.                   }
  1326.                   if(eval("\x01") == 262)
  1327.                   {
  1328.                      set("\x01",eval("\x01") + 187);
  1329.                      ┬º┬ºgoto(addr1950);
  1330.                   }
  1331.                   if(eval("\x01") == 449)
  1332.                   {
  1333.                      set("\x01",eval("\x01") - 241);
  1334.                      ┬º┬ºgoto(addr1950);
  1335.                      ┬º┬ºpush(true);
  1336.                   }
  1337.                   if(eval("\x01") == 108)
  1338.                   {
  1339.                      set("\x01",eval("\x01") + 656);
  1340.                      if(!┬º┬ºpop())
  1341.                      {
  1342.                         addr2073:
  1343.                         ┬º┬ºgoto(addr1950);
  1344.                      }
  1345.                      set("\x01",eval("\x01") - 394);
  1346.                      ┬º┬ºgoto(addr2073);
  1347.                   }
  1348.                   if(eval("\x01") != 963)
  1349.                   {
  1350.                      if(eval("\x01") == 670)
  1351.                      {
  1352.                         set("\x01",eval("\x01") - 221);
  1353.                         ┬º┬ºgoto(addr1950);
  1354.                      }
  1355.                      if(eval("\x01") == 330)
  1356.                      {
  1357.                         set("\x01",eval("\x01") - 192);
  1358.                         ┬º┬ºgoto(addr1950);
  1359.                      }
  1360.                      if(eval("\x01") == 138)
  1361.                      {
  1362.                         set("\x01",eval("\x01") + 18);
  1363.                         ┬º┬ºgoto(addr1950);
  1364.                         ┬º┬ºpush(true);
  1365.                      }
  1366.                      if(eval("\x01") == 617)
  1367.                      {
  1368.                         set("\x01",eval("\x01") - 535);
  1369.                         if(!┬º┬ºpop())
  1370.                         {
  1371.                            addr2149:
  1372.                            ┬º┬ºgoto(addr1950);
  1373.                         }
  1374.                         set("\x01",eval("\x01") + 481);
  1375.                         ┬º┬ºgoto(addr2149);
  1376.                      }
  1377.                      if(eval("\x01") == 208)
  1378.                      {
  1379.                         set("\x01",eval("\x01") + 128);
  1380.                         if(!┬º┬ºpop())
  1381.                         {
  1382.                            addr2170:
  1383.                            ┬º┬ºgoto(addr1950);
  1384.                         }
  1385.                         set("\x01",eval("\x01") - 329);
  1386.                         ┬º┬ºgoto(addr2170);
  1387.                      }
  1388.                      if(eval("\x01") != 336)
  1389.                      {
  1390.                         if(eval("\x01") == 7)
  1391.                         {
  1392.                            set("\x01",eval("\x01") + 272);
  1393.                            ┬º┬ºgoto(addr1950);
  1394.                         }
  1395.                         if(eval("\x01") == 563)
  1396.                         {
  1397.                            set("\x01",eval("\x01") - 425);
  1398.                            ┬º┬ºgoto(addr1950);
  1399.                         }
  1400.                         if(eval("\x01") == 595)
  1401.                         {
  1402.                            set("\x01",eval("\x01") - 316);
  1403.                            ┬º┬ºgoto(addr1950);
  1404.                         }
  1405.                         if(eval("\x01") == 279)
  1406.                         {
  1407.                            set("\x01",eval("\x01") + 338);
  1408.                            ┬º┬ºgoto(addr1950);
  1409.                            ┬º┬ºpush(true);
  1410.                         }
  1411.                         if(eval("\x01") != 82)
  1412.                         {
  1413.                            if(eval("\x01") == 205)
  1414.                            {
  1415.                               set("\x01",eval("\x01") + 41);
  1416.                               ┬º┬ºgoto(addr1950);
  1417.                            }
  1418.                            if(eval("\x01") == 38)
  1419.                            {
  1420.                               set("\x01",eval("\x01") + 208);
  1421.                               ┬º┬ºgoto(addr1950);
  1422.                            }
  1423.                            if(eval("\x01") == 246)
  1424.                            {
  1425.                               set("\x01",eval("\x01") - 138);
  1426.                               ┬º┬ºgoto(addr1950);
  1427.                               ┬º┬ºpush(true);
  1428.                            }
  1429.                            if(eval("\x01") != 764)
  1430.                            {
  1431.                               if(eval("\x01") == 370)
  1432.                               {
  1433.                                  set("\x01",eval("\x01") - 279);
  1434.                                  ┬º┬ºgoto(addr1950);
  1435.                               }
  1436.                               if(eval("\x01") == 109)
  1437.                               {
  1438.                                  set("\x01",eval("\x01") - 18);
  1439.                                  ┬º┬ºgoto(addr1950);
  1440.                               }
  1441.                               if(eval("\x01") == 389)
  1442.                               {
  1443.                                  set("\x01",eval("\x01") + 411);
  1444.                                  if(!eval(":∩┐╜\x17∩┐╜∩┐╜")["\x10"])
  1445.                                  {
  1446.                                     eval(":∩┐╜\x17∩┐╜∩┐╜")["\x10"] = new ┬º∩┐╜33∩┐╜\f╒ü∩┐╜┬º();
  1447.                                  }
  1448.                                  ┬º┬ºpop();
  1449.                                  if(!eval(":∩┐╜\x17∩┐╜∩┐╜")["\x10"][┬º┬ºconstant(3)])
  1450.                                  {
  1451.                                     eval("\x10")[┬º┬ºconstant(3)] extends eval(┬º┬ºconstant(12));
  1452.                                     _loc2_ = eval("\x10")[┬º┬ºconstant(3)] = function()
  1453.                                     {
  1454.                                        super();
  1455.                                        this[┬º┬ºconstant(4)](20);
  1456.                                        this[┬º┬ºconstant(5)](20);
  1457.                                        this[┬º┬ºconstant(8)](eval(┬º┬ºconstant(6))[┬º┬ºconstant(7)]);
  1458.                                        this[┬º┬ºconstant(9)](1);
  1459.                                        this[┬º┬ºconstant(10)](6);
  1460.                                        this[┬º┬ºconstant(11)](6);
  1461.                                        this[┬º┬ºconstant(14)](2.5 * eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)]);
  1462.                                        this[┬º┬ºconstant(15)](10000);
  1463.                                        this[┬º┬ºconstant(16)](32000);
  1464.                                        this[┬º┬ºconstant(17)](54000);
  1465.                                        this[┬º┬ºconstant(18)]();
  1466.                                     }[┬º┬ºconstant(19)];
  1467.                                     ┬º┬ºpush(┬º┬ºconstant(20)(eval("\x10")[┬º┬ºconstant(3)][┬º┬ºconstant(19)],null,1));
  1468.                                  }
  1469.                                  ┬º┬ºpop();
  1470.                                  break loop0;
  1471.                               }
  1472.                               if(eval("\x01") == 800)
  1473.                               {
  1474.                                  set("\x01",eval("\x01") - 800);
  1475.                                  break loop0;
  1476.                               }
  1477.                               break loop0;
  1478.                            }
  1479.                            set("\x01",eval("\x01") - 394);
  1480.                            break loop0;
  1481.                         }
  1482.                         set("\x01",eval("\x01") + 481);
  1483.                         break loop0;
  1484.                      }
  1485.                      set("\x01",eval("\x01") - 329);
  1486.                      break loop0;
  1487.                   }
  1488.                   set("\x01",eval("\x01") - 701);
  1489.                   break loop0;
  1490.                }
  1491.                set("\x01",eval("\x01") - 712);
  1492.                break loop0;
  1493.             }
  1494.             if(eval("\x01") == 30)
  1495.             {
  1496.                set("\x01",eval("\x01") + 749);
  1497.                continue;
  1498.             }
  1499.             if(eval("\x01") == 817)
  1500.             {
  1501.                set("\x01",eval("\x01") + 40);
  1502.                break loop0;
  1503.             }
  1504.             continue loop1;
  1505.          }
  1506.       }
  1507.    }
  1508.    else
  1509.    {
  1510.       if(eval("\x01") == 588)
  1511.       {
  1512.          set("\x01",eval("\x01") - 378);
  1513.          if(┬º┬ºpop())
  1514.          {
  1515.             set("\x01",eval("\x01") + 725);
  1516.          }
  1517.          continue;
  1518.       }
  1519.       if(eval("\x01") == 564)
  1520.       {
  1521.          set("\x01",eval("\x01") - 404);
  1522.          ┬º┬ºpush(true);
  1523.          continue;
  1524.       }
  1525.       if(eval("\x01") == 656)
  1526.       {
  1527.          set("\x01",eval("\x01") - 68);
  1528.          ┬º┬ºpush(true);
  1529.          continue;
  1530.       }
  1531.       if(eval("\x01") == 210)
  1532.       {
  1533.          set("\x01",eval("\x01") + 725);
  1534.          ┬º┬ºgoto(addr2479);
  1535.       }
  1536.       else
  1537.       {
  1538.          if(eval("\x01") != 597)
  1539.          {
  1540.             if(eval("\x01") != 454)
  1541.             {
  1542.                if(eval("\x01") == 916)
  1543.                {
  1544.                   set("\x01",eval("\x01") - 591);
  1545.                   continue;
  1546.                }
  1547.                if(eval("\x01") == 160)
  1548.                {
  1549.                   set("\x01",eval("\x01") + 552);
  1550.                   if(┬º┬ºpop())
  1551.                   {
  1552.                      set("\x01",eval("\x01") - 358);
  1553.                   }
  1554.                   continue;
  1555.                }
  1556.                if(eval("\x01") != 501)
  1557.                {
  1558.                   if(eval("\x01") == 375)
  1559.                   {
  1560.                      set("\x01",eval("\x01") + 1);
  1561.                      if(!┬º┬ºpop()[┬º┬ºpop()].LevelData_29)
  1562.                      {
  1563.                         Levels.LevelData_29 extends LevelDataBase;
  1564.                         _loc2_ = Levels.LevelData_29 = function()
  1565.                         {
  1566.                            super();
  1567.                            this.__set__LevelNumber(21);
  1568.                            this.__set__DisplayNumber(1);
  1569.                            this.__set__Difficulty(Game.DIFFICULTY_MEDIUM);
  1570.                            this.__set__SnackQuantity(1);
  1571.                            this.__set__MedalsQuantity(3);
  1572.                            this.__set__NormalClicks(4);
  1573.                            this.__set__SnackEntryRate(5 * LevelDataBase.SECONDS);
  1574.                            this.__set__MinimumTime(5000);
  1575.                            this.__set__NormalTime(16000);
  1576.                            this.__set__MaximumTime(22000);
  1577.                            this.doLoadData();
  1578.                         }.prototype;
  1579.                         ┬º┬ºpush(ASSetPropFlags(Levels.LevelData_29.prototype,null,1));
  1580.                      }
  1581.                      ┬º┬ºpop();
  1582.                      break;
  1583.                   }
  1584.                   if(eval("\x01") != 857)
  1585.                   {
  1586.                      if(eval("\x01") == 136)
  1587.                      {
  1588.                         set("\x01",eval("\x01") + 306);
  1589.                         if(!eval("∩┐╜p∩┐╜5∩┐╜")["p;\x12R"])
  1590.                         {
  1591.                            eval("∩┐╜p∩┐╜5∩┐╜")["p;\x12R"] = new ┬º\x16o ∩┐╜∩┐╜┬º();
  1592.                         }
  1593.                         ┬º┬ºpop();
  1594.                         if(!eval("∩┐╜p∩┐╜5∩┐╜")["p;\x12R"]["∩┐╜$∩┐╜∩┐╜8;∩┐╜"])
  1595.                         {
  1596.                            eval("p;\x12R")["∩┐╜$∩┐╜∩┐╜8;∩┐╜"] extends eval(┬º┬ºconstant(12));
  1597.                            _loc2_ = eval("p;\x12R")["∩┐╜$∩┐╜∩┐╜8;∩┐╜"] = function()
  1598.                            {
  1599.                               super();
  1600.                               this["O∩┐╜∩┐╜*∩┐╜f"](29);
  1601.                               this["D∩┐╜W"](9);
  1602.                               this[┬º┬ºconstant(8)](eval("\x1ei,|∩┐╜\x1b\x1f")[┬º┬ºconstant(7)]);
  1603.                               this[┬º┬ºconstant(9)](1);
  1604.                               this[┬º┬ºconstant(10)](3);
  1605.                               this[┬º┬ºconstant(11)](7);
  1606.                               this[┬º┬ºconstant(14)](2.5 * eval(┬º┬ºconstant(12))[┬º┬ºconstant(13)]);
  1607.                               this[┬º┬ºconstant(15)](6000);
  1608.                               this[┬º┬ºconstant(16)](15000);
  1609.                               this[┬º┬ºconstant(17)](24000);
  1610.                               this[┬º┬ºconstant(18)]();
  1611.                            }[┬º┬ºconstant(19)];
  1612.                            ┬º┬ºpush(┬º┬ºconstant(20)(eval("p;\x12R")["∩┐╜$∩┐╜∩┐╜8;∩┐╜"][┬º┬ºconstant(19)],null,1));
  1613.                         }
  1614.                         ┬º┬ºpop();
  1615.                         break;
  1616.                      }
  1617.                      if(eval("\x01") == 442)
  1618.                      {
  1619.                         set("\x01",eval("\x01") - 442);
  1620.                         break;
  1621.                      }
  1622.                   }
  1623.                   set("\x01",eval("\x01") - 721);
  1624.                }
  1625.                set("\x01",eval("\x01") + 461);
  1626.             }
  1627.             set("\x01",eval("\x01") - 129);
  1628.             continue;
  1629.             continue;
  1630.             ┬º┬ºpush(true);
  1631.             continue;
  1632.             break;
  1633.          }
  1634.          set("\x01",eval("\x01") + 230);
  1635.       }
  1636.    }
  1637.    ┬º┬ºgoto(addr3308);
  1638. }
  1639.